MacFormat 1995 August/macformat-027.iso/mac/Shareware City/Developers/Oberon⁄F/Mac/Mod/MemoryMgr

Oberon Document | 1994-06-07 | 13.8 KB | 505 lines | [oODC/obnF]

Documents.StdDocumentDesc
Documents.DocumentDesc
Containers.ViewDesc
Views.ViewDesc
Stores.StoreDesc
Documents.ModelDesc
Containers.ModelDesc
Models.ModelDesc
Stores.ElemDesc
TextViews.StdViewDesc
TextViews.ViewDesc
TextModels.StdModelDesc
TextModels.ModelDesc
TextModels.AttributesDesc
Geneva
Geneva
StdStamps.StdViewDesc
Geneva
Geneva
MODULE MacMemoryMgr;
(* cp
    IMPORT SYSTEM, MacTypes;
    CONST
        CODE = 1; NOSTKCHK = 4;
        D0 = 0; A0 = 8; A1 = 9;
        ApplLimit = 130H;
        SysZone = 2A6H;
        AppZone = 2AAH;
        GZRootHnd = 328H;
        MemTop = 108H;
    TYPE
        Ptr* = MacTypes.Ptr;
        Handle* = MacTypes.Handle;
        Size* = LONGINT;
        Zone* = RECORD (MacTypes.Data)
            bkLim*: Ptr;
            purgePtr: Ptr;
            hFstFree*: Ptr;
            zcbFree*: LONGINT;
            gzProc*: MacTypes.ProcPtr;
            moreMast*: INTEGER;
            flags: MacTypes.Set;
            cntRel, maxRel, cntNRel, maxNRel, cntEmpty, cntHandles: INTEGER;
            minCBFree: LONGINT;
            purgeProc*: MacTypes.ProcPtr;
            sparePtr, allocPtr: MacTypes.ProcPtr;
            heapData*: INTEGER
        END;
        THz* = POINTER TO Zone;
    VAR err*: INTEGER;
    PROCEDURE [CODE] setApplBase 0A0H, 057H;
    PROCEDURE [CODE] initZone 0A0H, 019H;
    PROCEDURE [CODE] setApplLimit 0A0H, 02DH;
    PROCEDURE [CODE] maxApplZone 0A0H, 063H;
    PROCEDURE [CODE] moreMasters 0A0H, 036H;
    PROCEDURE [CODE] getZone 0A1H, 01AH;
    PROCEDURE [CODE] setZone 0A0H, 01BH;
    PROCEDURE [CODE] newHandle 0A1H, 022H;
    PROCEDURE [CODE] disposHandle 0A0H, 023H;
    PROCEDURE [CODE] getHandleSize 0A0H, 025H;
    PROCEDURE [CODE] setHandleSize 0A0H, 024H;
    PROCEDURE [CODE] handleZone 0A1H, 026H;
    PROCEDURE [CODE] recoverHandle 0A1H, 028H;
    PROCEDURE [CODE] reallocHandle 0A0H, 027H;
    PROCEDURE [CODE] newPtr 0A1H, 01EH;
    PROCEDURE [CODE] newPtrClear 0A3H, 01EH;
    PROCEDURE [CODE] disposPtr 0A0H, 01FH;
    PROCEDURE [CODE] getPtrSize 0A0H, 021H;
    PROCEDURE [CODE] setPtrSize 0A0H, 020H;
    PROCEDURE [CODE] ptrZone 0A1H, 048H;
    PROCEDURE [CODE] freeMem 0A0H, 01CH;
    PROCEDURE [CODE] maxMem 0A1H, 01DH;
    PROCEDURE [CODE] compactMem 0A0H, 04CH;
    PROCEDURE [CODE] resrvMem 0A0H, 040H;
    PROCEDURE [CODE] purgeMem 0A0H, 04DH;
    PROCEDURE [CODE] emptyHandle 0A0H, 02BH;
    PROCEDURE [CODE] hLock 0A0H, 029H;
    PROCEDURE [CODE] hUnlock 0A0H, 02AH;
    PROCEDURE [CODE] hPurge 0A0H, 049H;
    PROCEDURE [CODE] hNoPurge 0A0H, 04AH;
    PROCEDURE [CODE] setGrowZone 0A0H, 04BH;
    PROCEDURE [CODE] blockMove 0A0H, 02EH;
    PROCEDURE [CODE] moveHHi 0A0H, 064H;
    PROCEDURE [CODE] handToHand 0A9H, 0E1H;
    PROCEDURE [CODE] ptrToHand 0A9H, 0E3H;
    PROCEDURE [CODE] ptrToXHand 0A9H, 0E2H;
    PROCEDURE [CODE] handAndHand 0A9H, 0E4H;
    PROCEDURE [CODE] ptrAndHand 0A9H, 0EFH;
    PROCEDURE [CODE] maxBlock 0A0H, 061H;
    PROCEDURE [CODE] purgeSpace 0A0H, 062H;
    PROCEDURE [CODE] stackSpace 0A0H, 065H;
    PROCEDURE [CODE] newEmptyHandle 0A0H, 066H;
    PROCEDURE [CODE] hSetRBit 0A0H, 067H;
    PROCEDURE [CODE] hClrRBit 0A0H, 068H;
    PROCEDURE [CODE] hGetState 0A0H, 069H;
    PROCEDURE [CODE] hSetState 0A0H, 06AH;
    (** Initialization and Allocation **)
    PROCEDURE [NOSTKCHK] SetApplBase* (startPtr: Ptr);
    BEGIN
        SYSTEM.PUTREG(A0, startPtr);
        setApplBase;
        SYSTEM.GETREG(D0, err)
    END SetApplBase;
    PROCEDURE [NOSTKCHK] InitZone* (pgrowZone: MacTypes.ProcPtr;
                            cmoreMasters: INTEGER; limitPtr, startPtr: Ptr);
    BEGIN
        SYSTEM.PUTREG(A0, startPtr);
        initZone;
        SYSTEM.GETREG(D0, err)
    END InitZone;
    PROCEDURE [NOSTKCHK] GetApplLimit* (): Ptr;
        VAR ptr: Ptr;
    BEGIN
        SYSTEM.MOVE(ApplLimit, SYSTEM.ADR(ptr), 4);
        RETURN ptr
    END GetApplLimit;
    PROCEDURE [NOSTKCHK] SetApplLimit* (zoneLimit: Ptr);
    BEGIN
        SYSTEM.PUTREG(A0, zoneLimit);
        setApplLimit;
        SYSTEM.GETREG(D0, err)
    END SetApplLimit;
    PROCEDURE [NOSTKCHK] MaxApplZone*;
    BEGIN
        maxApplZone;
        SYSTEM.GETREG(D0, err)
    END MaxApplZone;
    PROCEDURE [NOSTKCHK] MoreMasters*;
    BEGIN
        moreMasters;
        SYSTEM.GETREG(D0, err)
    END MoreMasters;
    (** Heap Zone Access **)
    PROCEDURE [NOSTKCHK] GetZone* (): THz;
        VAR t: THz;
    BEGIN
        getZone;
        SYSTEM.GETREG(D0, err);
        SYSTEM.GETREG(A0, t);
        RETURN t
    END GetZone;
    PROCEDURE [NOSTKCHK] SetZone* (hz: THz);
    BEGIN
        SYSTEM.PUTREG(A0, hz);
        setZone;
        SYSTEM.GETREG(D0, err)
    END SetZone;
    PROCEDURE [NOSTKCHK] SystemZone* (): THz;
        VAR t: THz;
    BEGIN
        SYSTEM.MOVE(SysZone, SYSTEM.ADR(t), 4);
        RETURN t
    END SystemZone;
    PROCEDURE [NOSTKCHK] ApplicZone* (): THz;
        VAR t: THz;
    BEGIN
        SYSTEM.MOVE(AppZone, SYSTEM.ADR(t), 4);
        RETURN t
    END ApplicZone;
    (** Allocating and Releasing Relocatable Blocks **)
    PROCEDURE [NOSTKCHK] NewHandle* (byteCount: Size): Handle;
        VAR h: Handle;
    BEGIN
        SYSTEM.PUTREG(D0, byteCount);
        newHandle;
        SYSTEM.GETREG(D0, err);
        SYSTEM.GETREG(A0, h);
        RETURN h
    END NewHandle;
    PROCEDURE [NOSTKCHK] DisposHandle* (h: Handle);
    BEGIN
        SYSTEM.PUTREG(A0, h);
        disposHandle;
        SYSTEM.GETREG(D0, err)
    END DisposHandle;
    PROCEDURE [NOSTKCHK] DisposeHandle* (h: Handle);
    BEGIN
        SYSTEM.PUTREG(A0, h);
        disposHandle;
        SYSTEM.GETREG(D0, err)
    END DisposeHandle;
    PROCEDURE [NOSTKCHK] GetHandleSize* (h: Handle): Size;
        VAR res: LONGINT;
    BEGIN
        SYSTEM.PUTREG(A0, h);
        getHandleSize;
        SYSTEM.GETREG(D0, res);
        IF res >= 0 THEN
            err := 0
        ELSE
            err := SHORT(res); res := 0
        END;
        RETURN res
    END GetHandleSize;
    PROCEDURE [NOSTKCHK] SetHandleSize* (h: Handle; newSize: Size);
    BEGIN
        SYSTEM.PUTREG(A0, h);
        SYSTEM.PUTREG(D0, newSize);
        setHandleSize;
        SYSTEM.GETREG(D0, err)
    END SetHandleSize;
    PROCEDURE [NOSTKCHK] HandleZone* (h: Handle): THz;
        VAR t: THz;
    BEGIN
        SYSTEM.PUTREG(A0, h);
        handleZone;
        SYSTEM.GETREG(D0, err);
        SYSTEM.GETREG(A0, t);
        RETURN t
    END HandleZone;
    PROCEDURE [NOSTKCHK] RecoverHandle* (p: Ptr): Handle;
        VAR h: Handle;
    BEGIN
        SYSTEM.PUTREG(A0, p);
        recoverHandle;
        err := 0;
        SYSTEM.GETREG(A0, h);
        RETURN h
    END RecoverHandle;
    PROCEDURE [NOSTKCHK] ReallocHandle* (h: MacTypes.Handle; byteCount: Size);
    BEGIN
        SYSTEM.PUTREG(A0, h);
        SYSTEM.PUTREG(D0, byteCount);
        reallocHandle;
        SYSTEM.GETREG(D0, err)
    END ReallocHandle;
    (** Allocating and Releasing Nonrelocatable Blocks **)
    PROCEDURE [NOSTKCHK] NewPtr* (byteCount: Size): Ptr;
        VAR p: Ptr;
    BEGIN
        SYSTEM.PUTREG(D0, byteCount);
        newPtr;
        SYSTEM.GETREG(D0, err);
        SYSTEM.GETREG(A0, p);
        RETURN p
    END NewPtr;
    PROCEDURE [NOSTKCHK] NewPtrClear* (byteCount: Size): Ptr;
        VAR p: Ptr;
    BEGIN
        SYSTEM.PUTREG(D0, byteCount);
        newPtrClear;
        SYSTEM.GETREG(D0, err);
        SYSTEM.GETREG(A0, p);
        RETURN p
    END NewPtrClear;
    PROCEDURE [NOSTKCHK] DisposPtr* (p: Ptr);
    BEGIN
        SYSTEM.PUTREG(A0, p);
        disposPtr;
        SYSTEM.GETREG(D0, err)
    END DisposPtr;
    PROCEDURE [NOSTKCHK] DisposePtr* (p: Ptr);
    BEGIN
        SYSTEM.PUTREG(A0, p);
        disposPtr;
        SYSTEM.GETREG(D0, err)
    END DisposePtr;
    PROCEDURE [NOSTKCHK] GetPtrSize* (p: Ptr): Size;
        VAR res: LONGINT;
    BEGIN
        SYSTEM.PUTREG(A0, p);
        getPtrSize;
        SYSTEM.GETREG(D0, res);
        IF res >= 0 THEN
            err := 0
        ELSE
            err := SHORT(res); res := 0
        END;
        RETURN res
    END GetPtrSize;
    PROCEDURE [NOSTKCHK] SetPtrSize* (p: Ptr; newSize: Size);
    BEGIN
        SYSTEM.PUTREG(A0, p);
        SYSTEM.PUTREG(D0, newSize);
        setPtrSize;
        SYSTEM.GETREG(D0, err)
    END SetPtrSize;
    PROCEDURE [NOSTKCHK] PtrZone* (p: Ptr): THz;
        VAR t: THz;
    BEGIN
        SYSTEM.PUTREG(A0, p);
        ptrZone;
        SYSTEM.GETREG(D0, err);
        SYSTEM.GETREG(A0, t);
        RETURN t
    END PtrZone;
    (** Freeing Space in the Heap **)
    PROCEDURE [NOSTKCHK] FreeMem* (): LONGINT;
        VAR size: Size;
    BEGIN
        freeMem;
        err := 0;
        SYSTEM.GETREG(D0, size);
        RETURN size
    END FreeMem;
    PROCEDURE [NOSTKCHK] MaxMem* (VAR grow: Size): Size;
        VAR size: Size;
    BEGIN
        maxMem;
        err := 0;
        SYSTEM.GETREG(A0, grow);
        SYSTEM.GETREG(D0, size);
        RETURN size
    END MaxMem;
    PROCEDURE [NOSTKCHK] CompactMem* (cbNeeded: Size): Size;
        VAR size: Size;
    BEGIN
        SYSTEM.PUTREG(D0, cbNeeded);
        compactMem;
        err := 0;
        SYSTEM.GETREG(D0, size);
        RETURN size
    END CompactMem;
    PROCEDURE [NOSTKCHK] ResrvMem* (cbNeeded: Size);
    BEGIN
        SYSTEM.PUTREG(D0, cbNeeded);
        resrvMem;
        SYSTEM.GETREG(D0, err)
    END ResrvMem;
    PROCEDURE [NOSTKCHK] PurgeMem* (cbNeeded: Size);
    BEGIN
        SYSTEM.PUTREG(D0, cbNeeded);
        purgeMem;
        SYSTEM.GETREG(D0, err)
    END PurgeMem;
    PROCEDURE [NOSTKCHK] EmptyHandle* (h: Handle);
    BEGIN
        SYSTEM.PUTREG(A0, h);
        emptyHandle;
        SYSTEM.GETREG(D0, err)
    END EmptyHandle;
    (** Properties of Relocatable Blocks **)
    PROCEDURE [NOSTKCHK] HLock* (h: Handle);
    BEGIN
        SYSTEM.PUTREG(A0, h);
        hLock;
        SYSTEM.GETREG(D0, err)
    END HLock;
    PROCEDURE [NOSTKCHK] HUnlock* (h: Handle);
    BEGIN
        SYSTEM.PUTREG(A0, h);
        hUnlock;
        SYSTEM.GETREG(D0, err)
    END HUnlock;
    PROCEDURE [NOSTKCHK] HPurge* (h: Handle);
    BEGIN
        SYSTEM.PUTREG(A0, h);
        hPurge;
        SYSTEM.GETREG(D0, err)
    END HPurge;
    PROCEDURE [NOSTKCHK] HNoPurge* (h: Handle);
    BEGIN
        SYSTEM.PUTREG(A0, h);
        hNoPurge;
        SYSTEM.GETREG(D0, err)
    END HNoPurge;
    (** Grow Zone Operations **)
    PROCEDURE [NOSTKCHK] SetGrowZone* (growZone: MacTypes.ProcPtr);
    BEGIN
        SYSTEM.PUTREG(A0, growZone);
        setGrowZone;
        SYSTEM.GETREG(D0, err)
    END SetGrowZone;
    PROCEDURE [NOSTKCHK] GZSaveHnd* (): Handle;
        VAR h: Handle;
    BEGIN
        SYSTEM.MOVE(GZRootHnd, SYSTEM.ADR(h), 4);
        RETURN h
    END GZSaveHnd;
    (** Miscellaneous Operations **)
    PROCEDURE [NOSTKCHK] BlockMove* (srcPtr, destPtr: Ptr; byteCount: Size);
    BEGIN
        SYSTEM.PUTREG(A0, srcPtr);
        SYSTEM.PUTREG(A1, destPtr);
        SYSTEM.PUTREG(D0, byteCount);
        blockMove;
        SYSTEM.GETREG(D0, err)
    END BlockMove;
    PROCEDURE [NOSTKCHK] TopMem* (): Ptr;
        VAR p: Ptr;
    BEGIN
        SYSTEM.MOVE(MemTop, SYSTEM.ADR(p), 4);
        RETURN p
    END TopMem;
    PROCEDURE [NOSTKCHK] MoveHHi* (h: MacTypes.Handle);
    BEGIN
        SYSTEM.PUTREG(A0, h);
        moveHHi;
        SYSTEM.GETREG(D0, err)
    END MoveHHi;
    PROCEDURE [NOSTKCHK] MemError* (): MacTypes.OSErr;
    BEGIN
        RETURN err
    END MemError;
    (** Pointer and Handle Manipulation **)
    PROCEDURE [NOSTKCHK] HandToHand* (VAR theHndl: Handle): INTEGER;
    BEGIN
        SYSTEM.PUTREG(A0, theHndl);
        handToHand;
        SYSTEM.GETREG(D0, err);
        SYSTEM.GETREG(A0, theHndl);
        RETURN err
    END HandToHand;
    PROCEDURE [NOSTKCHK] PtrToHand* (srcPtr: Ptr; VAR dstHndl: Handle; size: LONGINT): INTEGER;
    BEGIN
        SYSTEM.PUTREG(A0, srcPtr);
        SYSTEM.PUTREG(D0, size);
        ptrToHand;
        SYSTEM.GETREG(D0, err);
        SYSTEM.GETREG(A0, dstHndl);
        RETURN err
    END PtrToHand;
    PROCEDURE [NOSTKCHK] PtrToXHand* (srcPtr: Ptr; dstHndl: Handle; size: LONGINT): INTEGER;
    BEGIN
        SYSTEM.PUTREG(A0, srcPtr);
        SYSTEM.PUTREG(A1, dstHndl);
        SYSTEM.PUTREG(D0, size);
        ptrToXHand;
        SYSTEM.GETREG(D0, err);
        RETURN err
    END PtrToXHand;
    PROCEDURE [NOSTKCHK] HandAndHand* (hand1, hand2: Handle): INTEGER;
    BEGIN
        SYSTEM.PUTREG(A0, hand1);
        SYSTEM.PUTREG(A1, hand2);
        handAndHand;
        SYSTEM.GETREG(D0, err);
        RETURN err
    END HandAndHand;
    PROCEDURE [NOSTKCHK] PtrAndHand* (pntr: Ptr; hndl: Handle; size: LONGINT): INTEGER;
    BEGIN
        SYSTEM.PUTREG(D0, size);
        SYSTEM.PUTREG(A0, pntr);
        SYSTEM.PUTREG(A1, hndl);
        ptrAndHand;
        SYSTEM.GETREG(D0, err);
        RETURN err
    END PtrAndHand;
    (** **)
    PROCEDURE [NOSTKCHK] MaxBlock* (): LONGINT;
        VAR res: LONGINT;
    BEGIN
        maxBlock;
        SYSTEM.GETREG(D0, res);
        RETURN res
    END MaxBlock;
    PROCEDURE [NOSTKCHK] PurgeSpace* (VAR total, contig: LONGINT);
    BEGIN
        purgeSpace;
        SYSTEM.GETREG(D0, total);
        SYSTEM.GETREG(A0, contig)
    END PurgeSpace;
    PROCEDURE [NOSTKCHK] StackSpace* (): LONGINT;
    BEGIN
        stackSpace;
        SYSTEM.GETREG(D0, err)
    END StackSpace;
    PROCEDURE [NOSTKCHK] NewEmptyHandle* (): Handle;
        VAR h: Handle;
    BEGIN
        newEmptyHandle;
        SYSTEM.GETREG(D0, err);
        SYSTEM.GETREG(A0, h);
        RETURN h
    END NewEmptyHandle;
    PROCEDURE [NOSTKCHK] HSetRBit* (h: Handle);
    BEGIN
        SYSTEM.PUTREG(A0, h);
        hSetRBit;
        SYSTEM.GETREG(D0, err)
    END HSetRBit;
    PROCEDURE [NOSTKCHK] HClrRBit* (h: Handle);
    BEGIN
        SYSTEM.PUTREG(A0, h);
        hClrRBit;
        SYSTEM.GETREG(D0, err)
    END HClrRBit;
    PROCEDURE [NOSTKCHK] HGetState* (h: Handle): MacTypes.Set;
        VAR s: MacTypes.Set;
    BEGIN
        SYSTEM.PUTREG(A0, h);
        hGetState;
        SYSTEM.GETREG(D0, s);
        RETURN s
    END HGetState;
    PROCEDURE [NOSTKCHK] HSetState* (h: Handle; flags: MacTypes.Set);
    BEGIN
        SYSTEM.PUTREG(A0, h);
        SYSTEM.PUTREG(D0, flags);
        hSetState;
        SYSTEM.GETREG(D0, err)
    END HSetState;
END MacMemoryMgr.
TextControllers.StdCtrlDesc
TextControllers.ControllerDesc
Containers.ControllerDesc
Controllers.ControllerDesc
TextRulers.StdRulerDesc
TextRulers.RulerDesc
TextRulers.StdStyleDesc
TextRulers.StyleDesc
TextRulers.AttributesDesc
Geneva
Documents.ControllerDesc